// 聊天API服务
import request, { API_BASE_URL } from './request.js'
import {ElMessage} from "element-plus";

/**
 * 发送聊天消息到后台
 * @param {Object} params - 请求参数
 * @param {string} params.message - 用户消息
 * @param {Array} params.chat_history - 聊天历史
 * @param {boolean} params.stream - 是否流式返回
 * @returns {Promise} API响应
 */
export const sendChatMessage = async (params) => {
  try {
    const response = await request.post('/chat', params)
    return response.data
  } catch (error) {
    console.error('API调用错误:', error)
    throw error
  }
}

/**
 * 测试API连接
 * @returns {Promise} 连接测试结果
 */
export const testConnection = async () => {
  try {
    const response = await request.get('/health')
    return response.status === 200
  } catch (error) {
    console.error('连接测试失败:', error)
    return false
  }
}

/**
 * 发送流式聊天消息
 * @param {Object} params - 请求参数
 * @param {Function} onMessage - 接收消息回调
 * @param {Function} onError - 错误回调
 * @param {Function} onComplete - 完成回调
 */
export const sendStreamChatMessage = async (params, abortSignal, onMessage, onError, onComplete) => {
  try {
    console.log('发送流式请求:', params)
    
    // 直接使用fetch API来处理SSE
    const response = await fetch(`${API_BASE_URL}/chat/stream`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(params),
      signal: abortSignal // 添加中断信号
    })

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`)
    }

    const reader = response.body.getReader()
    const decoder = new TextDecoder()
    let buffer = ''

    while (true) {
      const { done, value } = await reader.read()
      if (done) break

      buffer += decoder.decode(value, { stream: true })
      const lines = buffer.split('\n')
      
      // 保留最后一行（可能不完整）
      buffer = lines.pop() || ''

      for (const line of lines) {
        if (line.trim() && line.startsWith('data: ')) {
          try {
            const jsonStr = line.slice(6).trim()
            console.log('接收到SSE数据:', jsonStr)
            
            if (jsonStr) {
              const data = JSON.parse(jsonStr)
              console.log('解析后的数据:', data)
              
              if (data.error) {
                onError?.(new Error(data.error))
                return
              }
              if (data.done) {
                console.log('流式输出完成')
                onComplete?.()
                return
              }
              if (data.chunk) {
                console.log('调用onMessage回调:', data.chunk)
                onMessage?.(data.chunk)
              }
            }
          } catch (e) {
            console.warn('解析SSE数据失败:', e, '原始数据:', line)
            // 如果JSON解析失败，可能是纯文本数据，直接处理
            const textData = line.slice(6).trim()
            if (textData) {
              onMessage?.(textData)
            }
          }
        }
      }
    }

    // 处理最后的缓冲区
    if (buffer && buffer.trim() && buffer.startsWith('data: ')) {
      try {
        const jsonStr = buffer.slice(6).trim()
        if (jsonStr) {
          const data = JSON.parse(jsonStr)
          if (data.error) {
            onError?.(new Error(data.error))
            return
          }
          if (data.done) {
            onComplete?.()
            return
          }
          if (data.chunk) {
            onMessage?.(data.chunk)
          }
        }
      } catch (e) {
        console.warn('解析最后SSE数据失败:', e)
        // 如果JSON解析失败，可能是纯文本数据
        const textData = buffer.slice(6).trim()
        if (textData) {
          onMessage?.(textData)
        }
      }
    }

    console.log('流式读取完成，调用onComplete')
    onComplete?.()
  } catch (error) {
    console.error('流式API调用错误:', error)
    onError?.(error)
  }
}

/**
 * 上传文档到知识库
 * @param {Object} params - 上传参数
 * @param {File[]} params.files - 要上传的文件数组
 * @param {string} params.splitter_type - 分割器类型: markdown_header, recursive, numeric_markdown, q&a
 * @param {string} params.chunk_sizes - 层次大小(仅hierarchical,逗号分隔)
 * @param {Function} onProgress - 上传进度回调
 * @returns {Promise} 上传结果
 */
export const uploadDocuments = async (params, onProgress) => {
  try {
    const { files, splitter_type = 'q&a', chunk_sizes = '2048' ,collection_name } = params
    
    // 创建FormData
    const formData = new FormData()
    
    // 添加文件
    files.forEach(file => {
      formData.append('files', file)
    })
    
    // 添加其他参数
    formData.append('splitter_type', splitter_type)
    formData.append('chunk_sizes', chunk_sizes)
    formData.append('collection_name', collection_name)

    console.log('上传文档参数:', {
      fileCount: files.length,
      splitter_type,
      chunk_sizes,
      fileNames: files.map(f => f.name)
    })
    
    // 使用fetch直接发送FormData（不通过axios，因为axios会自动处理Content-Type）
    const response = await fetch(`${API_BASE_URL}/rag/add/upload`, {
      method: 'POST',
      body: formData,
      // 注意：不要手动设置Content-Type，让浏览器自动设置boundary
    })
    
    if (!response.ok) {
      const errorText = await response.text()
      throw new Error(`HTTP error! status: ${response.status}, message: ${errorText}`)
    }
    
    const result = await response.json()
    return result
  } catch (error) {
    console.error('文档上传失败:', error)
    return {
      code: 500,
      msg: error.message
    }
  }
}

/**
 * 获取知识库列表
 * @returns {Promise} 知识库列表
 */
export const getKnowledgeBases = async () => {
  try {
    const response = await request.get('/rag/knowledge/list')
    return response.data
  } catch (error) {
    ElMessage.error('获取知识库列表失败！');
    throw error
  }
}

/**
 * 删除知识库文档
 * @param {string} documentId - 文档ID
 * @returns {Promise} 删除结果
 */
export const deleteDocument = async (documentId) => {
  try {
    const response = await request.delete(`/knowledge/document/${documentId}`)
    return response.data
  } catch (error) {
    console.error('删除文档失败:', error)
    throw error
  }
}

/**
 * 搜索知识库
 * @param {Object} params - 搜索参数
 * @param {string} params.query - 搜索关键词
 * @param {number} params.top_k - 返回结果数量
 * @returns {Promise} 搜索结果
 */
export const searchKnowledge = async (params) => {
  try {
    const response = await request.post('/knowledge/search', params)
    return response.data
  } catch (error) {
    console.error('搜索知识库失败:', error)
    throw error
  }
} 